reportDeprecation() dedups per api+detail and logs at trace level by
default; NS_DEPRECATIONS=warn|error previews the stricter stages so the
same call sites can be escalated over releases. Wired at the external
entry points only: param-name hook invocation, require-time extension
registration, and dynamicCall help templating.

A class migrated off property injection has neither $hooksService nor
$injector, so the decorator threw at hook-execution time. The global
injector must stay last in the chain - tests stub the instance
properties and rely on them winning.

Yok keeps its entire public surface, subclassability, and the global
$injector, while storage and resolution delegate to the new container.
Command routing, key commands, and the public-API builder are unchanged.
Every legacy member now carries @deprecated JSDoc naming its
replacement, mirrored on IInjector.

DoctorService and ProjectNameService become @contract abstract classes;
their impls are renamed *Impl (externally invisible - outside resolution
is by string name or token, never class identity). The subpath resolves
through contracts/package.json rather than an exports map, so existing
deep requires keep working, and the entry point is side-effect-free so a
duplicated CLI copy in an extensions tree never boots a second runtime.

Fixtures exercise the surfaces third parties rely on: param-name hook
signatures across every payload shape and influence channel (mutation,
function-return middleware, abort), require-time extension registration
against global.$injector including hierarchical commands, and the full
IInjector facade surface. Notably they pin that a hook naming an
unwrapped payload key (the after-watchAction shape) is skipped as
invalid - resolution changes must not resurrect long-dead hooks.

dependency-injection.md covers tokens (@contract), inject()/Injector,
provider kinds, resolution semantics, forwardRef, coexistence with the
legacy $injector, and a legacy-to-new quick reference. extending-cli.md
leads with the recommended hook pattern - inject() works directly in
hook bodies because they run in an injection context, pinned by a new
compat test - and demotes parameter-name injection to a labeled legacy
section. String-token lookups are framed as the migration bridge, not a
co-equal API.

The hook deprecation tracer now flags only hooks that actually use
param-name service injection; a hookArgs-only signature follows the
recommended pattern and stays silent.

IInjector recomposes from per-subsystem faces - CommandRegistry,
KeyCommandRegistry, ModuleRegistry, PublicApiBuilder - each an @contract
token the facade registers itself under. One object still implements
everything until the subsystems are physically extracted; extraction
then becomes a provider swap for the face's token instead of a consumer
migration. Consumers can depend on the narrow face they actually use,
and deprecation becomes per-face instead of a flat everything-is-legacy.

The contracts are internal (lib/common/contracts) and deliberately not
re-exported from nativescript/contracts; promoting one is a per-contract
decision.

- doctor-service: printWarnings accepts an optional trackResult matching
  its contracts; runSetupScript returns the setup script result instead
  of resolving undefined; canExecuteLocalBuild no longer dereferences
  its optional argument
- deprecation tracer: a report dropped for lack of a logger is no
  longer latched as delivered - it reports once a logger exists
- yok: global.$injector is an accessor pair, so a direct third-party
  assignment stays synchronized with the binding getInjector() reads
- docs: note the useValue + shared:false quirk; show where Injector is
  imported from in the late-lookup example

Hook authors can now export a definition built with defineHook instead
of a plain function whose shape the CLI has to infer. The handler takes
a context object with the operation payload, an explicit wrap() for
middleware around the hooked method, and abort() for stopping the hook
as either a failure or a warning.

Definitions are marked with Symbol.for("nativescript:cli:hookDefinition")
so a duplicated CLI copy in an extension's dependency tree still
recognizes them. The definition path skips parameter-name resolution,
the projectData promotion hack and the deprecation report; plain
function hooks keep running through the existing path unchanged.

lib/common/define-hook.ts is import-free so a hook can load it without
booting a second runtime, and it is re-exported from
nativescript/contracts.

Yok extends Injector on the base branch, so definitions run in
runInInjectionContext(this.$injector, ...) directly and
inject(Injector) inside a hook returns the facade itself.